/**
 * ArvoreAtividades.java
 * 
 * Este código foi baseado no exemplo do site do ZK: http://www.zkoss.org/zkdemo/tree/dynamic_tree
 *
 * Projeto: SGA-LEDS
 *
 * Rodrigo Soares Maia IFES - Instituto Federal do Espírito Santo - Campus Serra
 */
package controleAtividades.cih;

import controleAtividades.cci.CtrlAtividades;
import controleInterno.cci.CtrlInterno;
import controleAtividades.cdp.Atividade;
import controleInterno.cdp.Colaborador;
import controleAtividades.cdp.NivelAtividade;
import static controleAtividades.cdp.NivelAtividade.GERAL;
import static controleAtividades.cdp.NivelAtividade.GRUPO;
import static controleAtividades.cdp.NivelAtividade.INDIVIDUAL;
import controleInterno.cdp.Projeto;
import java.awt.MenuItem;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.zkoss.zk.ui.Component;
import org.zkoss.zk.ui.Executions;
import org.zkoss.zk.ui.event.DropEvent;
import org.zkoss.zk.ui.event.Event;
import org.zkoss.zk.ui.event.EventListener;
import org.zkoss.zk.ui.event.Events;
import org.zkoss.zk.ui.event.KeyEvent;
import org.zkoss.zk.ui.event.MouseEvent;
import org.zkoss.zk.ui.select.SelectorComposer;
import org.zkoss.zk.ui.select.annotation.Wire;
import org.zkoss.zul.Button;
import org.zkoss.zul.DefaultTreeNode;
import org.zkoss.zul.Hlayout;
import org.zkoss.zul.Image;
import org.zkoss.zul.Label;
import org.zkoss.zul.Menubar;
import org.zkoss.zul.Menuitem;
import org.zkoss.zul.Menupopup;
import org.zkoss.zul.Messagebox;
import org.zkoss.zul.Textbox;
import org.zkoss.zul.Tree;
import org.zkoss.zul.Treecell;
import org.zkoss.zul.Treechildren;
import org.zkoss.zul.Treecol;
import org.zkoss.zul.Treeitem;
import org.zkoss.zul.TreeitemRenderer;
import org.zkoss.zul.Treerow;
import org.zkoss.zul.Window;

public class ArvoreAtividades extends SelectorComposer<Component>
{
    @Wire
    private Window arvoreAtividades;
    @Wire
    private Tree arvoreProjeto;
    @Wire
    private Treecol nomeProjeto;
    @Wire
    private Treecol opcoes;
    @Wire
    private Menuitem menuNovaAtividade;
    @Wire
    private Menuitem menuRelatorioRegistros;
    @Wire
    private Menuitem menuRelatorioExecucao;
    @Wire
    private Menubar menu;
    
    private AdvancedTreeModel atividadeTreeModel;
    private Projeto p;
    private Colaborador c;
    private NivelAtividade n;
    private Atividade atividadeClicada;
    
    CtrlAtividades ctrl = CtrlAtividades.getInstance();

    public void doAfterCompose(Component comp) throws Exception
    {
        super.doAfterCompose(comp);
        
        ctrl.setArvore(this);
        
        p = (Projeto) Executions.getCurrent().getSession().getAttribute("projeto");
        c = (Colaborador) Executions.getCurrent().getSession().getAttribute("colaborador");
        
        n = (NivelAtividade) Executions.getCurrent().getArg().get("nivel");
        
        List<Atividade> l = ctrl.obterAtividades(p);
        
        System.out.println(l);
        
        atividadeTreeModel = new AdvancedTreeModel(new ListaAtividades(l, n, c).getRoot());
        
        atividadeTreeModel.setMultiple(true);
        
        arvoreProjeto.setItemRenderer(new AtividadeTreeRenderer());
        arvoreProjeto.setModel(atividadeTreeModel);
        nomeProjeto.setLabel(p.getNome());
        opcoes.setLabel("Opções");
        
        menu.setVisible(false);
        
        System.out.println("Quantidade: " + atividadeTreeModel.getChildCount(atividadeTreeModel._root));
        
            //setando a coluna nomeProjeto como "droppable"
            // Both category row and atividade row can be item dropped
            nomeProjeto.setDroppable("true");
            nomeProjeto.addEventListener(Events.ON_DROP, new EventListener<Event>()
            {
                @SuppressWarnings("unchecked")
                @Override
                public void onEvent(Event event) throws Exception
                {
                    // The dragged target is a TreeRow belongs to an
                    // Treechildren of TreeItem.
                    Treeitem draggedItem = (Treeitem) ((DropEvent) event).getDragged().getParent();
                    TreeNode draggedValue = (TreeNode) draggedItem.getValue();
                    int nos, posicao;
                    
                    //if (temPai(draggedValue.getData()))
                    if (((Atividade) draggedValue.getData()).getAtividadePai() != null) //se a atividade tiver um pai, ele eh tirado
                    {
                        nos = atividadeTreeModel.getChildCount(atividadeTreeModel._root);
                        posicao = nos;

                        atividadeTreeModel.remove(draggedValue);

                        atividadeTreeModel.insert(atividadeTreeModel._root, posicao, posicao, new TreeNode[] {draggedValue});
                        
                        //tirando o pai da atividade que foi movida
                        ctrl.trocaPai((Atividade) draggedValue.getData(), null);
                    }
                    else //senao, nada eh feito
                    {
                        //nao faz nada
                    }
                } 
            });
        
        if (n == NivelAtividade.GERAL && p.getGerente() == c)
        {
            //adicionando evento no botao de criar nova atividade 
            menuNovaAtividade.addEventListener(Events.ON_CLICK, new EventListener<Event>()
            {
                @Override
                public void onEvent(Event event) throws Exception
                {
                    //adicionando uma nova atividade
                    Map atributos = new HashMap();
                    int posicao;
                    
                    //Adicionando o usuario atual como alocado, pois ele tambem serah o responsavel
                    List<Colaborador> alocados = new ArrayList<Colaborador>();
                    alocados.add(c);

                    atributos.put("descricao", "Nova Atividade");
                    atributos.put("dataInicio", Calendar.getInstance());
                    atributos.put("dataFim", Calendar.getInstance());
                    atributos.put("progresso", 0.0);
                    atributos.put("duracao", 0.0);
                    atributos.put("projeto", p);
                    atributos.put("tipo", null);
                    atributos.put("responsavel", c); 
                    atributos.put("nivel", n);
                    atributos.put("atividadePai", null);
                    
                    Atividade novaAtividade = ctrl.salvarAtividade(atributos, alocados);
                    TreeNode novoNo = new TreeNode(novaAtividade);
                    novoNo.setNovo(true);
                    
                    int nos = atividadeTreeModel.getChildCount(atividadeTreeModel._root);
                    
                    if (nos > 0) //se existir alguma atividade na arvore
                    {
                        posicao = nos;
                    }
                    else //se a arvore estiver vazia
                    {
                        posicao = 0;
                    }
                    
                    atividadeTreeModel.insert(atividadeTreeModel._root, posicao, posicao, new TreeNode[] {novoNo});
                }
            });
            menu.setVisible(true);
        }
        
        //Map estadoArvore = new HashMap();
        Executions.getCurrent().getSession().setAttribute("estadoArvore", null);
    }

    /**
     * The structure of tree
     *
     * <pre>
     * &lt;treeitem>
     *   &lt;treerow>
     *     &lt;treecell>...&lt;/treecell>
     *   &lt;/treerow>
     *   &lt;treechildren>
     *     &lt;treeitem>...&lt;/treeitem>
     *   &lt;/treechildren>
     * &lt;/treeitem>
     * </pre>
     */
    private final class AtividadeTreeRenderer implements TreeitemRenderer<TreeNode>
    {
        /**
         * Renderiza todos os nos da arvore.
         * @param treeItem
         * @param treeNode
         * @param index
         * @throws Exception 
         */
        @Override
        public void render(final Treeitem treeItem, TreeNode treeNode, int index) throws Exception
        {
            TreeNode atn = treeNode;
            Atividade atividade = (Atividade) atn.getData();
            Treerow dataRow = new Treerow();
            dataRow.setParent(treeItem);
            treeItem.setValue(atn);
            treeItem.setOpen(atn.isOpen());

            Hlayout hlAtividade = new Hlayout();
            Hlayout hlOpcao = new Hlayout();

            hlAtividade.appendChild(new Label(atividade.getDescricao()));

            Textbox t = new Textbox(atividade.getDescricao());
            
            t.addEventListener(Events.ON_OK, new EventListener<Event>()
            {
                @Override
                public void onEvent(Event event) throws Exception
                {
                    TreeNode noClicado = (TreeNode) ((Treeitem) event.getTarget().getParent().getParent().getParent().getParent()).getValue();

                    Atividade a = (Atividade) noClicado.getData();

                    Treeitem itemClicado = (Treeitem) ((KeyEvent) event).getTarget().getParent().getParent().getParent().getParent();

                    Textbox textbox = (Textbox) itemClicado.getChildren().get(0).getChildren().get(0).getChildren().get(0).getChildren().get(1);

                    a.setDescricao(textbox.getValue());

                    ctrl.alterarAtividade(a);
                }
            });
            t.setVisible(false);
            hlAtividade.appendChild(t);

            hlAtividade.setSclass("h-inline-block");

            //icone de nova atividade; criarah uma atividade filha da clicada baseada nas propriedades da clicada
            Image plusIcon = new Image("/images/plus-icon.png");
            plusIcon.setTooltiptext("Cria uma atividade filha.");
            plusIcon.addEventListener(Events.ON_CLICK, new EventListener<Event>()
            {
                @Override
                public void onEvent(Event event) throws Exception
                {
                    //adicionando uma nova atividade "filha" da atual
                    Treeitem itemClicado = (Treeitem) ((MouseEvent) event).getTarget().getParent().getParent().getParent().getParent();
                    TreeNode no = (TreeNode) itemClicado.getValue();
                    Atividade a = (Atividade) no.getData();

                    Map atributos = new HashMap();
                    
                    //Adicionando o usuario atual como alocado, pois ele tambem serah o responsavel
                    List<Colaborador> alocados = new ArrayList<>();
                    alocados.add(c);

                    atributos.put("descricao", "Nova Atividade");
                    atributos.put("dataInicio", Calendar.getInstance()); //setando data atual
                    atributos.put("dataFim", a.getDataFim()); //setando data fim da atividade pai
                    atributos.put("progresso", 0.0);
                    atributos.put("duracao", 0.0);
                    atributos.put("nivel", n);
                    atributos.put("projeto", p);
                    atributos.put("tipo", a.getTipo());
                    atributos.put("responsavel", c);
                    atributos.put("atividadePai", a);

                    Atividade novaAtividade = ctrl.salvarAtividade(atributos, alocados);
                    
                    //pegando o indice do noh em que foi clicado para se adicionar na proxima, ou seja, em baixo
                    int indexAtual = no.getParent().getIndex(no);
                    TreeNode novoNo = new TreeNode(novaAtividade);
                    novoNo.setNovo(true);
                    //atividadeTreeModel.insert(atividadeTreeModel._root, indexAtual+1, indexAtual+1, new TreeNode[] {novoNo});
                    
                    //GAMBI se o pai for uma folha, recria o model..
                    if (no.isLeaf())
                    {
                        System.out.println("entrou no isLeaf!!");
                        
                        guardaEstadoAtual();
                        
                        refreshModel();
                    }
                    else
                    {
                        atividadeTreeModel.add((TreeNode) treeItem.getValue(),
                                new DefaultTreeNode[]
                                {
                                    novoNo
                                });
                    }     
                }
            });

            //icone de editar a atividade na propria linha (sem abrir outra janela)
            Image editIcon = new Image("/images/edit-icon.png");
            editIcon.addEventListener(Events.ON_CLICK, new EventListener<Event>()
            {
                @Override
                public void onEvent(Event event) throws Exception
                {
                    //pegando a linha em questao
                    Treerow treeRow = (Treerow) ((MouseEvent) event).getTarget().getParent().getParent().getParent();

                    tornarEditavel(treeRow);
                }
            });
            
            //icone de salvar a atividade editada na propria linha
            Image okIcon = new Image("/images/ok-icon.png");
            okIcon.addEventListener(Events.ON_CLICK, new EventListener<Event>()
            {
                @Override
                public void onEvent(Event event) throws Exception
                {
                    TreeNode noClicado = (TreeNode) ((Treeitem) event.getTarget().getParent().getParent().getParent().getParent()).getValue();

                    Atividade a = (Atividade) noClicado.getData();

                    Treeitem itemClicado = (Treeitem) ((MouseEvent) event).getTarget().getParent().getParent().getParent().getParent();

                    Textbox textbox = (Textbox) itemClicado.getChildren().get(0).getChildren().get(0).getChildren().get(0).getChildren().get(1);

                    a.setDescricao(textbox.getValue());

                    ctrl.alterarAtividade(a);
                }
            });
            
            //icone de cancelar edicao da atividade na propria linha
            Image cancelIcon = new Image("/images/cancel-icon.png");
            cancelIcon.addEventListener(Events.ON_CLICK, new EventListener<Event>()
            {
                @Override
                public void onEvent(Event event) throws Exception
                {
                    //cancela
                    //somente atualiza a arvore
                    refreshArvore();
                }
            });
            
            //icone de excluir a atividade em questao
            Image deleteIcon = new Image("/images/lixeira-icon.png");
            deleteIcon.addEventListener(Events.ON_CLICK, new EventListener<Event>()
            {
                @Override
                public void onEvent(Event event) throws Exception
                {
                    Treeitem itemClicado = (Treeitem) ((MouseEvent) event).getTarget().getParent().getParent().getParent().getParent();
                    TreeNode no = (TreeNode) itemClicado.getValue();
                    Atividade a = (Atividade) no.getData();
                    
                    atividadeClicada = a;

                    //TODO tentar deletar o item em questão
                    //TODO aqui q eh feita a verificacao para ver se tem filhas e perguntar?
                    
                    if (ctrl.obterFilhas(a).isEmpty())
                    {
                        ctrl.apagarAtividade(a);
                        atividadeTreeModel.remove(no);                       
                    }
                    else
                    {
                        confirmacaoExclusao();
                        atividadeTreeModel.remove(no);
                    }
                }
            });
            
            //icone de criar um registro para a atividade em questao
            Image registroIcon = new Image("/images/clock-icon.png");
            registroIcon.addEventListener(Events.ON_CLICK, new EventListener<Event>()
            {
                @Override
                public void onEvent(Event event) throws Exception
                {
                    Treeitem itemClicado = (Treeitem) ((MouseEvent) event).getTarget().getParent().getParent().getParent().getParent();
                    TreeNode no = (TreeNode) itemClicado.getValue();
                    Atividade a = (Atividade) no.getData();
                    
                    ctrl.abrirIncluirRegistro(a);
                }
            });
            
            //invisibilizando os icones na linha
            plusIcon.setVisible(false);
            editIcon.setVisible(false);
            deleteIcon.setVisible(false);
            okIcon.setVisible(false);
            cancelIcon.setVisible(false);
            registroIcon.setVisible(false);
            
            //setando os icones no hlayout; a ordem de adicao eh importante
            hlOpcao.appendChild(plusIcon);
            hlOpcao.appendChild(editIcon);
            hlOpcao.appendChild(deleteIcon);
            hlOpcao.appendChild(registroIcon);
            hlOpcao.appendChild(okIcon);
            hlOpcao.appendChild(cancelIcon);

            Treecell tcAtividade = new Treecell();
            tcAtividade.appendChild(hlAtividade);

            Treecell tcOpcao = new Treecell();
            tcOpcao.appendChild(hlOpcao);

            dataRow.setDraggable("true");

            dataRow.appendChild(tcAtividade);
            dataRow.appendChild(tcOpcao);
            
//            Menupopup menuContexto = new Menupopup();
//            Menuitem menuItem = new Menuitem("Instanciar Tipos...");
//            menuItem.setParent(menuContexto);
//            
//            //tcAtividade.setContext(menuContexto);
//            deleteIcon.setContext(menuContexto);
//            
//             menuContexto.addEventListener(Events.ON_CLICK, new EventListener<Event>()
//            {
//                @Override
//                public void onEvent(Event event) throws Exception
//                {
//                    ctrl.abrirPagGerenciaTipos(false);
////                    //adicionando uma nova atividade
////                    Map atributos = new HashMap();
////                    int posicao;
////                    
////                    //Adicionando o usuario atual como alocado, pois ele tambem serah o responsavel
////                    List<Colaborador> alocados = new ArrayList<Colaborador>();
////                    alocados.add(c);
////
////                    atributos.put("descricao", "Nova Atividade");
////                    atributos.put("dataInicio", Calendar.getInstance());
////                    atributos.put("dataFim", Calendar.getInstance());
////                    atributos.put("progresso", 0.0);
////                    atributos.put("duracao", 0.0);
////                    atributos.put("projeto", p);
////                    atributos.put("tipo", null);
////                    atributos.put("responsavel", c); 
////                    atributos.put("nivel", n);
////                    atributos.put("atividadePai", null);
////                    
////                    Atividade novaAtividade = ctrl.salvarAtividade(atributos, alocados);
////                    TreeNode novoNo = new TreeNode(novaAtividade);
////                    novoNo.setNovo(true);
////                    
////                    int nos = atividadeTreeModel.getChildCount(atividadeTreeModel._root);
////                    
////                    if (nos > 0) //se existir alguma atividade na arvore
////                    {
////                        posicao = nos;
////                    }
////                    else //se a arvore estiver vazia
////                    {
////                        posicao = 0;
////                    }
////                    
////                    atividadeTreeModel.insert(atividadeTreeModel._root, posicao, posicao, new TreeNode[] {novoNo});
//                }
//            });

            dataRow.addEventListener(Events.ON_DOUBLE_CLICK, new EventListener<Event>()
            {
                @Override
                public void onEvent(Event event) throws Exception
                {
                    TreeNode noClicado = (TreeNode) ((Treeitem) event.getTarget().getParent()).getValue();
                    Atividade atividade = (Atividade) noClicado.getData();
                    
                    if (n == NivelAtividade.GERAL)
                    {
                        if (c == p.getGerente())
                        {
                            ctrl.abrirEditarAtividade(atividade);
                        }
                        else
                        {
                            ctrl.abrirConsultarAtividade(atividade);
                        }
                    }
                    else if (atividade.getNivel() == n)
                    {
                        ctrl.abrirEditarAtividade(atividade);
                    }
                    else
                    {
                        ctrl.abrirConsultarAtividade(atividade);
                    } 
                }
            });

            // Both category row and atividade row can be item dropped
            dataRow.setDroppable("true");
            dataRow.addEventListener(Events.ON_DROP, new EventListener<Event>()
            {
                @SuppressWarnings("unchecked")
                @Override
                public void onEvent(Event event) throws Exception
                {
                    // The dragged target is a TreeRow belongs to an
                    // Treechildren of TreeItem.
                    Treeitem draggedItem = (Treeitem) ((DropEvent) event).getDragged().getParent();
                    TreeNode draggedValue = (TreeNode) draggedItem.getValue();
                    //Treeitem parentItem = treeItem.getParentItem();
                    
                    Atividade novoPai = (Atividade) ((TreeNode)treeItem.getValue()).getData();
                    Atividade raizDosFilhos = (Atividade) draggedValue.getData();
                    
                    //trocando o pai da atividade que foi movida
                    ctrl.trocaPai(raizDosFilhos, novoPai);
                    
                    //GAMBI se o novo pai for uma folha, recria o model..
                    if (((TreeNode) treeItem.getValue()).isLeaf())
                    {
                        System.out.println("entrou no isLeaf!!");
                        
                        guardaEstadoAtual();
                        
                        refreshModel();
                    }
                    else
                    {
                        atividadeTreeModel.remove(draggedValue);
                        atividadeTreeModel.add((TreeNode) treeItem.getValue(),
                                new DefaultTreeNode[]
                                {
                                    draggedValue
                                });
                    }     
                } 
            });

            //TODO teste...
            dataRow.addEventListener(Events.ON_CLICK, new EventListener<Event>()
            {
                @SuppressWarnings("unchecked")
                @Override
                public void onEvent(Event event) throws Exception
                {
                    System.out.println("situacao da linha: " + "treeItem.isOpen() == " + treeItem.isOpen());
                    
                    guardaEstadoAtual();
                } 
            });

            //evento para quando o mouse eh colocado sobre a linha
            dataRow.addEventListener(Events.ON_MOUSE_OVER, new EventListener<Event>()
            {
                @SuppressWarnings("unchecked")
                @Override
                public void onEvent(Event event) throws Exception
                {
                    //pegando a linha em questao
                    Treerow treeRow = (Treerow) ((MouseEvent) event).getTarget();
                    
                    TreeNode treenode = ((Treeitem) treeRow.getParent()).getValue();
                    
                    Atividade atividade = (Atividade) treenode.getData();
                    
                    //pegando a imagem que esta num hlayout que esta na segunda celula da linha
                    Image plus = (Image) treeRow.getChildren().get(1).getChildren().get(0).getChildren().get(0);
                    Image edit = (Image) treeRow.getChildren().get(1).getChildren().get(0).getChildren().get(1);
                    Image delete = (Image) treeRow.getChildren().get(1).getChildren().get(0).getChildren().get(2);
                    Image registro = (Image) treeRow.getChildren().get(1).getChildren().get(0).getChildren().get(3);
                    
                    //se o nivel eh geral... e o colaborador eh o gerente do projeto
                    if (n == NivelAtividade.GERAL)
                    {
                        if (p.getGerente() == c)
                        {
                            plus.setVisible(true);
                            delete.setVisible(true);
                            edit.setVisible(true);
                        }
                    }
                    else if (n == NivelAtividade.INDIVIDUAL)
                    {
                        if (ctrl.ehAlocado(atividade, c))
                        {
                            registro.setVisible(true);
                            plus.setVisible(true);
                        }

                        if (atividade.getNivel() == NivelAtividade.INDIVIDUAL)
                        {
                            delete.setVisible(true);
                            edit.setVisible(true);
                        }
                    }
                    else // se o nivel for de grupo (detalhamento)
                    {
                        if (ctrl.ehAlocado(atividade, c))
                        {
                            plus.setVisible(true);
                        }
                        if (atividade.getNivel() == NivelAtividade.GRUPO)
                        {
                            plus.setVisible(true);
                            delete.setVisible(true);
                            edit.setVisible(true);
                        }
                    }
                }
            });
            
            //evento para quando o mouse foi tirado da linha
            dataRow.addEventListener(Events.ON_MOUSE_OUT, new EventListener<Event>()
            {
                @SuppressWarnings("unchecked")
                @Override
                public void onEvent(Event event) throws Exception
                {
                    //pegando a linha em questao
                    Treerow treeRow = (Treerow) ((MouseEvent) event).getTarget();
                    //pegando as imagens que estao num hlayout que esta na segunda celula da linha
                    Image plus = (Image) treeRow.getChildren().get(1).getChildren().get(0).getChildren().get(0);
                    Image edit = (Image) treeRow.getChildren().get(1).getChildren().get(0).getChildren().get(1);
                    Image delete = (Image) treeRow.getChildren().get(1).getChildren().get(0).getChildren().get(2);
                    Image registro = (Image) treeRow.getChildren().get(1).getChildren().get(0).getChildren().get(3);
                    plus.setVisible(false);
                    edit.setVisible(false);
                    delete.setVisible(false);
                    registro.setVisible(false);
                }
            });
            
            //GAMBI verificar como se faz para forcar a chamada do evento de edicao ao criar a atividade
            if (atn.ehNovo())
            {
               atn.setNovo(false);
               tornarEditavel(dataRow);
            }
            
            //GAMBI!!
            Map estadoArvore = (Map) Executions.getCurrent().getSession().getAttribute("estadoArvore");
            if (estadoArvore != null)
            {
                if (estadoArvore.containsKey(atividade.getId()))
                {
                    treeItem.setOpen((boolean) estadoArvore.get(atividade.getId()));
                }
            }
            
        }

        private boolean temPai(Atividade atividade)
        {
            return atividade.getAtividadePai() != null;
        }
        
        private void tornarEditavel(Treerow treeRow){
            //pegando as imagens que estao num hlayout que esta na segunda celula da linha
            Image plus = (Image) treeRow.getChildren().get(1).getChildren().get(0).getChildren().get(0);
            Image edit = (Image) treeRow.getChildren().get(1).getChildren().get(0).getChildren().get(1);
            Image delete = (Image) treeRow.getChildren().get(1).getChildren().get(0).getChildren().get(2);
            Image registro = (Image) treeRow.getChildren().get(1).getChildren().get(0).getChildren().get(3);
            plus.setVisible(false);
            edit.setVisible(false);
            delete.setVisible(false);
            registro.setVisible(false);
            
            //removendo listeners
            Iterable iterable;
            Iterator iterator;
            
            iterable = treeRow.getEventListeners(Events.ON_MOUSE_OVER);
            iterator = iterable.iterator();
            while (iterator.hasNext())
            {
                //iterator.remove();
                treeRow.removeEventListener(Events.ON_MOUSE_OVER, (EventListener<Event>) iterator.next());
            }
            
            iterable = treeRow.getEventListeners(Events.ON_MOUSE_OUT);
            iterator = iterable.iterator();
            while (iterator.hasNext())
            {
                //iterator.remove();
                treeRow.removeEventListener(Events.ON_MOUSE_OUT, (EventListener<Event>) iterator.next());
            }
            
            //visible true nos inputs e false nos labels
            Label label = (Label) treeRow.getChildren().get(0).getChildren().get(0).getChildren().get(0);
            Textbox input = (Textbox) treeRow.getChildren().get(0).getChildren().get(0).getChildren().get(1);

            label.setVisible(false);
            input.setVisible(true);

            //visible true nos botoes ok e cancel
            //pegando a imagem que esta num hlayout que esta na segunda celula da linha
            Image ok = (Image) treeRow.getChildren().get(1).getChildren().get(0).getChildren().get(4);
            Image cancel = (Image) treeRow.getChildren().get(1).getChildren().get(0).getChildren().get(5);
            ok.setVisible(true);
            cancel.setVisible(true); //TODO criar metodo interno para dar visible true ou false nas imagens
            
            input.setFocus(true);
        }
    }
    
    public void confirmacaoExclusao() //Metodo criado para exibir a msg de exclusão!
    {
        Messagebox.Button b1 = Messagebox.Button.YES;       
        Messagebox.Button b2 = Messagebox.Button.NO;
        Messagebox.Button [] b = new Messagebox.Button[2];
        b[0] = b1;
        b[1] = b2;

        EventListener <Messagebox.ClickEvent> e = new EventListener() { //Captura os eventos do mouse
            public void onEvent(Event evt) throws InterruptedException {
                if (evt.getName().equals("onYes"))
                { //Se o usuário clicar no botão de sim na popup
                    ctrl.apagarAtividadeCascata(atividadeClicada);
                    
                    System.out.println("atividadeClicada: " + atividadeClicada.getDescricao());
                }
            }
        };
        
        Messagebox.show("Deseja excluir a atividade e suas filhas?", "Confirmação", b, Messagebox.QUESTION, e); //Mensagem de exclusão
    }
    
    public void guardaEstadoAtual()
    {
        //Collection<Treeitem> treeitens = arvoreProjeto.getItems();
        
        //List<Treeitem> treeitens;
        
        int tam = arvoreProjeto.getItems().size();
        
        Object treeitens[] = new Object[arvoreProjeto.getItems().size()];
        
        treeitens = arvoreProjeto.getItems().toArray(treeitens);

        Map estadoArvore = new HashMap();
        
        for (int i = 0; i < tam; i++)
        {
            System.out.println(((Atividade)((TreeNode) ((Treeitem) treeitens[i]).getValue()).getData()).getDescricao());
            
            Treeitem item = (Treeitem) treeitens[i];
            
            Atividade a = (Atividade)((TreeNode) item.getValue()).getData();
            
            estadoArvore.put(a.getId(), item.isOpen());
        }
        
        Executions.getCurrent().getSession().setAttribute("estadoArvore", estadoArvore);
    }
    
    public void refreshArvore()
    {
        arvoreProjeto.setModel(arvoreProjeto.getModel());
    }
    
    public void refreshModel()
    {
        //GAMBI
        atividadeTreeModel = null;
        
        atividadeTreeModel = new AdvancedTreeModel(new ListaAtividades(ctrl.obterAtividades(p), n, c).getRoot());
        arvoreProjeto.setModel(atividadeTreeModel);
    }
}
